#pragma once

#include "Common.hpp"
#include "Log.hpp"

// Socket 类
#define MAXLISTEN 1024
class Socket{
private:
    // 1.创建套接字
    bool Create(){
        _sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if(_sockfd < 0){
            LOG_ERROR("CREATE SOCKET ERROR");
            return false;
        }
        return true;
    }
    // 2.绑定地址信息
    bool Bind(const std::string &ip, uint16_t port){
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());

        int ret = bind(_sockfd, (struct sockaddr*)&addr, sizeof(addr));
        if(ret < 0){
            LOG_ERROR("BIND SOCKET ERROR");
            return false;
        }
        return true;
    }
    // 3.监听
    bool Listen(int backlog = MAXLISTEN){
        int ret = listen(_sockfd, backlog);
        if(ret < 0){
            LOG_ERROR("LISTEN SOCKET ERROR");
            return false;
        }
        return true;
    }
    // 4.向服务器发起连接
    bool Connect(const std::string &ip, uint16_t port){
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());

        int ret = connect(_sockfd, (struct sockaddr*)&addr, sizeof(addr));
        if(ret < 0){
            LOG_ERROR("CONNECT SOCKET ERROR");
            return false;
        }
        return true;
    }
    
    
public:
    Socket():_sockfd(-1){}
    ~Socket(){Close();}
    Socket(int sockfd): _sockfd(sockfd){}
    // 避免拷贝问题
    Socket(const Socket&) = delete;
    Socket& operator=(const Socket&) = delete;

    int Fd() const {return _sockfd;}


    // 5.获取新连接
    int Accept(){
        int newfd = accept(_sockfd, nullptr, nullptr);
        if(newfd < 0){
            LOG_ERROR("ACCEPT SOCKET ERROR");
            return -1;
        }
        return newfd; // 返回新连接的套接字
    }
    // 6.接收数据
    ssize_t Recv(void *buf, size_t len, int flag = 0){
        ssize_t ret = recv(_sockfd, buf, len, flag);
        // < 0 出错
        // = 0 连接断开
        // > 0 接收成功
        if(ret <= 0){
            // EAGAIN | EWOULDBLOCK: 当前 socket 的非阻塞缓冲区没有数据了
            // EINTR: 当前 socket 的阻塞等待被信号中断
            // ECONNRESET: 连接重置
            // ENOTCONN: 套接字未连接
            // ETIMEDOUT: 接收超时
            if(errno == EAGAIN || errno == EINTR){
                return 0; // 表示: 这次发送没有发送成功, 需重试
            }
            LOG_ERROR("Recv SOCKET ERROR %s" , strerror(errno));
            return -1; // 其他错误
        }    
        return ret; // 实际接收长度
    }
    ssize_t NonBlockRecv(void *buf, size_t len){
        return Recv(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT 表示当前接收为非阻塞。
    }

    // 7.发送数据
    ssize_t Send(const void* buf, size_t len, int flag = 0){
        ssize_t ret = send(_sockfd, buf, len, flag);
        if(ret < 0){
            if(errno == EAGAIN || errno == EINTR){
                return 0; // 表示: 这次发送没有发送成功, 需重试
            }
            LOG_ERROR("SEND SOCKET ERROR %s" , strerror(errno));
            return -1; // 其他错误 
        }
        return ret;
    }
    ssize_t NonBlockSend(const void* buf, size_t len){
        return Send(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT 表示当前发送为非阻塞
    }

    // 8.关闭套接字
    void Close(){
        if(_sockfd = 0){
            close(_sockfd);
            _sockfd = -1;
        }
    }

    // 9.设置套接字选项 -- 开启地址端口重用
    void ReuseAddr() {
        int opt = 1;
        // SO_REUSEADDR: 允许重用本地地址和端口
        // SO_REUSEPORT: 允许重用本地端口
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void*)&opt, sizeof(opt));
        opt = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void*)&opt, sizeof(opt));
    }

    // 10.设置套接字阻塞属性 -- 设置为非阻塞
    void NonBlock(){
        int flag = fcntl(_sockfd, F_GETFL, 0);
        if(flag == -1){
            LOG_ERROR("GET SOCKET FLAG ERROR");
            return;
        }
        int ret = fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
        if(ret < 0){
            LOG_ERROR("SET SOCKET NONBLOCK ERROR");
            return;
        }
    }

    // 9. 创建一个服务器连接
    bool CreateServer(uint16_t port, const std::string &ip = "0.0.0.0", bool nonblock_flag = false){
        if(!Create()) return false;
        if(nonblock_flag) NonBlock(); // 设置非阻塞
        ReuseAddr(); // 设置地址端口重用

        if(!Bind(ip, port)) return false;
        if(!Listen()) return false;
        return true;
    }   
    // 10. 创建一个客户端连接
    bool CreateClient(uint16_t port, const std::string &ip){
        // 1. 创建套接字 2. 连接服务器
        if(!Create()) return false;
        if(!Connect(ip, port)) return false;
        return true;
    }

private:
    int _sockfd;
};